package com.example.onlinemonitoring.model;

import com.example.onlinemonitoring.model.common.sensor;
import java.util.Date;
import javax.persistence.*;

public class Jddlsensor extends sensor {
    /**
     * DLHL传感器的编号。主键。自动递增。
     */
    @Id
    private Long id;

    /**
     * 外键。变电站的编号。
     */
    private Integer stationid;

    /**
     * 设备组
     */
    private Integer devicegroup;

    /**
     * 设备地址。传感器的站号。
     */
    private Integer deviceaddr;

    /**
     * 母线地址
     */
    private Integer lastdcurrentaddr;

    /**
     * 数据保存时间
     */
    private Date lastdatatime;

    /**
     * 上一次提交到历史表时间
     */
    private Date lasthisdatatime;

    /**
     * 监测点的名称。
     */
    private String pointname;

    /**
     * A相电流
     */
    private Float lastacurrent;

    /**
     * B相电流
     */
    private Float lastbcurrent;

    /**
     * C相电流
     */
    private Float lastccurrent;

    /**
     * D相电流
     */
    private Float lastdcurrent;

    /**
     * A1相电流
     */
    private Float lasta1current;

    /**
     * B1相电流
     */
    private Float lastb1current;

    /**
     * C1相电流
     */
    private Float lastc1current;

    /**
     * D1相电流
     */
    private Float lastd1current;

    /**
     * A相电流带系数
     */
    private Float lastacurrentratio;

    /**
     * B相电流带系数
     */
    private Float lastbcurrentratio;

    /**
     * C相电流带系数
     */
    private Float lastccurrentratio;

    /**
     * D相电流带系数
     */
    private Float lastdcurrentratio;

    /**
     * A1相电流带系数
     */
    private Float lasta1currentratio;

    /**
     * B1相电流带系数
     */
    private Float lastb1currentratio;

    /**
     * C1相电流带系数
     */
    private Float lastc1currentratio;

    /**
     * D1相电流带系数
     */
    private Float lastd1currentratio;

    /**
     * 三相不平衡系数
     */
    private Float lastcoefficient;

    /**
     * 三相1不平衡系数
     */
    private Float lastcoefficient1;

    /**
     * A相报警状态
     */
    private Integer lastaalarmstatus;

    /**
     * B相报警状态
     */
    private Integer lastbalarmstatus;

    /**
     * C相报警状态
     */
    private Integer lastcalarmstatus;

    /**
     * A1相报警状态
     */
    private Integer lasta1alarmstatus;

    /**
     * B1相报警状态
     */
    private Integer lastb1alarmstatus;

    /**
     * C1相报警状态
     */
    private Integer lastc1alarmstatus;

    /**
     * A相报警状态
     */
    private Integer lastaralarmstatus;

    /**
     * B相报警状态
     */
    private Integer lastbralarmstatus;

    /**
     * C相报警状态
     */
    private Integer lastcralarmstatus;

    /**
     * A1相报警状态
     */
    private Integer lastar1alarmstatus;

    /**
     * B1相报警状态
     */
    private Integer lastbr1alarmstatus;

    /**
     * C1相报警状态
     */
    private Integer lastcr1alarmstatus;

    /**
     * A相报警状态
     */
    private Integer lastabcalarmstatus;

    /**
     * A1相报警状态
     */
    private Integer lastabc1alarmstatus;

    /**
     * 备注信息。
     */
    private String memo;

    /**
     * vue版的XY坐标
     */
    private String style;

    /**
     * 值为0为投用,值为1已投用
     */
    private Integer inuse;

    /**
     * 报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     */
    private Integer lastalarmlevel;

    /**
     * 上次报警消息。
     */
    private String lastalarmmessage;

    /**
     * 通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     */
    private Integer lastcommunicationstatus;

    /**
     * 电流报警值
     */
    private Float currentalarmvlaue;

    /**
     * 电流报警解除值
     */
    private Float currentalarmrelievevlaue;

    /**
     * 电流预警值
     */
    private Float currentwarnvlaue;

    /**
     * 电流预警解除值
     */
    private Float currentwarnrelievevlaue;

    /**
     * 电流比报警值
     */
    private Float currentpercentagealarmvlaue;

    /**
     * 电流比报警解除值
     */
    private Float currentpercentagealarmrelievevlaue;

    /**
     * 电流比预警值
     */
    private Float currentpercentagewarnvlaue;

    /**
     * 电流比预警解除值
     */
    private Float currentpercentagewarnrelievevlaue;

    /**
     * 不平衡系数报警值
     */
    private Float coefficientalarmvlaue;

    /**
     * 不平衡系数报警解除值
     */
    private Float coefficientalarmrelievevlaue;

    /**
     * 不平衡系数预警值
     */
    private Float coefficientwarnvlaue;

    /**
     * 不平衡系数预警解除值
     */
    private Float coefficientwarnrelievevlaue;

    /**
     * A相电流系数>5
     */
    private Float acurrentcoefficientgreatevalue;

    /**
     * 偏移量
     */
    private Float acurrentbgreatevalue;

    /**
     * B相电流系数>5
     */
    private Float bcurrentcoefficientgreatevalue;

    private Float bcurrentbgreatevalue;

    /**
     * C相电流系数>5
     */
    private Float ccurrentcoefficientgreatevalue;

    private Float ccurrentbgreatevalue;

    /**
     * A1相电流系数>5
     */
    private Float a1currentcoefficientgreatevalue;

    /**
     * B1相电流系数>5
     */
    private Float b1currentcoefficientgreatevalue;

    /**
     * C1相电流系数>5
     */
    private Float c1currentcoefficientgreatevalue;

    /**
     * 母线电流系数>5
     */
    private Float dcurrentcoefficientgreatevalue;

    private Float dcurrentbgreatevalue;

    /**
     * A相电流系数<5
     */
    private Float acurrentcoefficientlessvalue;

    /**
     * 偏移量
     */
    private Float acurrentblessvalue;

    /**
     * B相电流系数<5
     */
    private Float bcurrentcoefficientlessvalue;

    private Float bcurrentblessvalue;

    /**
     * C相电流系数<5
     */
    private Float ccurrentcoefficientlessvalue;

    private Float cccurrentblessvalue;

    /**
     * A1相电流系数<5
     */
    private Float a1currentcoefficientlessvalue;

    /**
     * B1相电流系数<5
     */
    private Float b1currentcoefficientlessvalue;

    /**
     * C1相电流系数<5
     */
    private Float c1currentcoefficientlessvalue;

    private String ccurrentblessvalue;

    private Float dcurrentcoefficientlessvalue;

    private Float dcurrentblessvalue;

    /**
     * 获取DLHL传感器的编号。主键。自动递增。
     *
     * @return id - DLHL传感器的编号。主键。自动递增。
     */
    public Long getId() {
        return id;
    }

    /**
     * 设置DLHL传感器的编号。主键。自动递增。
     *
     * @param id DLHL传感器的编号。主键。自动递增。
     */
    public void setId(Long id) {
        this.id = id;
    }

    /**
     * 获取外键。变电站的编号。
     *
     * @return stationid - 外键。变电站的编号。
     */
    public Integer getStationid() {
        return stationid;
    }

    /**
     * 设置外键。变电站的编号。
     *
     * @param stationid 外键。变电站的编号。
     */
    public void setStationid(Integer stationid) {
        this.stationid = stationid;
    }

    /**
     * 获取设备组
     *
     * @return devicegroup - 设备组
     */
    public Integer getDevicegroup() {
        return devicegroup;
    }

    /**
     * 设置设备组
     *
     * @param devicegroup 设备组
     */
    public void setDevicegroup(Integer devicegroup) {
        this.devicegroup = devicegroup;
    }

    /**
     * 获取设备地址。传感器的站号。
     *
     * @return deviceaddr - 设备地址。传感器的站号。
     */
    public Integer getDeviceaddr() {
        return deviceaddr;
    }

    /**
     * 设置设备地址。传感器的站号。
     *
     * @param deviceaddr 设备地址。传感器的站号。
     */
    public void setDeviceaddr(Integer deviceaddr) {
        this.deviceaddr = deviceaddr;
    }

    /**
     * 获取母线地址
     *
     * @return lastdcurrentaddr - 母线地址
     */
    public Integer getLastdcurrentaddr() {
        return lastdcurrentaddr;
    }

    /**
     * 设置母线地址
     *
     * @param lastdcurrentaddr 母线地址
     */
    public void setLastdcurrentaddr(Integer lastdcurrentaddr) {
        this.lastdcurrentaddr = lastdcurrentaddr;
    }

    /**
     * 获取数据保存时间
     *
     * @return lastdatatime - 数据保存时间
     */
    public Date getLastdatatime() {
        return lastdatatime;
    }

    /**
     * 设置数据保存时间
     *
     * @param lastdatatime 数据保存时间
     */
    public void setLastdatatime(Date lastdatatime) {
        this.lastdatatime = lastdatatime;
    }

    /**
     * 获取上一次提交到历史表时间
     *
     * @return lasthisdatatime - 上一次提交到历史表时间
     */
    public Date getLasthisdatatime() {
        return lasthisdatatime;
    }

    /**
     * 设置上一次提交到历史表时间
     *
     * @param lasthisdatatime 上一次提交到历史表时间
     */
    public void setLasthisdatatime(Date lasthisdatatime) {
        this.lasthisdatatime = lasthisdatatime;
    }

    /**
     * 获取监测点的名称。
     *
     * @return pointname - 监测点的名称。
     */
    public String getPointname() {
        return pointname;
    }

    /**
     * 设置监测点的名称。
     *
     * @param pointname 监测点的名称。
     */
    public void setPointname(String pointname) {
        this.pointname = pointname;
    }

    /**
     * 获取A相电流
     *
     * @return lastacurrent - A相电流
     */
    public Float getLastacurrent() {
        return lastacurrent;
    }

    /**
     * 设置A相电流
     *
     * @param lastacurrent A相电流
     */
    public void setLastacurrent(Float lastacurrent) {
        this.lastacurrent = lastacurrent;
    }

    /**
     * 获取B相电流
     *
     * @return lastbcurrent - B相电流
     */
    public Float getLastbcurrent() {
        return lastbcurrent;
    }

    /**
     * 设置B相电流
     *
     * @param lastbcurrent B相电流
     */
    public void setLastbcurrent(Float lastbcurrent) {
        this.lastbcurrent = lastbcurrent;
    }

    /**
     * 获取C相电流
     *
     * @return lastccurrent - C相电流
     */
    public Float getLastccurrent() {
        return lastccurrent;
    }

    /**
     * 设置C相电流
     *
     * @param lastccurrent C相电流
     */
    public void setLastccurrent(Float lastccurrent) {
        this.lastccurrent = lastccurrent;
    }

    /**
     * 获取D相电流
     *
     * @return lastdcurrent - D相电流
     */
    public Float getLastdcurrent() {
        return lastdcurrent;
    }

    /**
     * 设置D相电流
     *
     * @param lastdcurrent D相电流
     */
    public void setLastdcurrent(Float lastdcurrent) {
        this.lastdcurrent = lastdcurrent;
    }

    /**
     * 获取A1相电流
     *
     * @return lasta1current - A1相电流
     */
    public Float getLasta1current() {
        return lasta1current;
    }

    /**
     * 设置A1相电流
     *
     * @param lasta1current A1相电流
     */
    public void setLasta1current(Float lasta1current) {
        this.lasta1current = lasta1current;
    }

    /**
     * 获取B1相电流
     *
     * @return lastb1current - B1相电流
     */
    public Float getLastb1current() {
        return lastb1current;
    }

    /**
     * 设置B1相电流
     *
     * @param lastb1current B1相电流
     */
    public void setLastb1current(Float lastb1current) {
        this.lastb1current = lastb1current;
    }

    /**
     * 获取C1相电流
     *
     * @return lastc1current - C1相电流
     */
    public Float getLastc1current() {
        return lastc1current;
    }

    /**
     * 设置C1相电流
     *
     * @param lastc1current C1相电流
     */
    public void setLastc1current(Float lastc1current) {
        this.lastc1current = lastc1current;
    }

    /**
     * 获取D1相电流
     *
     * @return lastd1current - D1相电流
     */
    public Float getLastd1current() {
        return lastd1current;
    }

    /**
     * 设置D1相电流
     *
     * @param lastd1current D1相电流
     */
    public void setLastd1current(Float lastd1current) {
        this.lastd1current = lastd1current;
    }

    /**
     * 获取A相电流带系数
     *
     * @return lastacurrentratio - A相电流带系数
     */
    public Float getLastacurrentratio() {
        return lastacurrentratio;
    }

    /**
     * 设置A相电流带系数
     *
     * @param lastacurrentratio A相电流带系数
     */
    public void setLastacurrentratio(Float lastacurrentratio) {
        this.lastacurrentratio = lastacurrentratio;
    }

    /**
     * 获取B相电流带系数
     *
     * @return lastbcurrentratio - B相电流带系数
     */
    public Float getLastbcurrentratio() {
        return lastbcurrentratio;
    }

    /**
     * 设置B相电流带系数
     *
     * @param lastbcurrentratio B相电流带系数
     */
    public void setLastbcurrentratio(Float lastbcurrentratio) {
        this.lastbcurrentratio = lastbcurrentratio;
    }

    /**
     * 获取C相电流带系数
     *
     * @return lastccurrentratio - C相电流带系数
     */
    public Float getLastccurrentratio() {
        return lastccurrentratio;
    }

    /**
     * 设置C相电流带系数
     *
     * @param lastccurrentratio C相电流带系数
     */
    public void setLastccurrentratio(Float lastccurrentratio) {
        this.lastccurrentratio = lastccurrentratio;
    }

    /**
     * 获取D相电流带系数
     *
     * @return lastdcurrentratio - D相电流带系数
     */
    public Float getLastdcurrentratio() {
        return lastdcurrentratio;
    }

    /**
     * 设置D相电流带系数
     *
     * @param lastdcurrentratio D相电流带系数
     */
    public void setLastdcurrentratio(Float lastdcurrentratio) {
        this.lastdcurrentratio = lastdcurrentratio;
    }

    /**
     * 获取A1相电流带系数
     *
     * @return lasta1currentratio - A1相电流带系数
     */
    public Float getLasta1currentratio() {
        return lasta1currentratio;
    }

    /**
     * 设置A1相电流带系数
     *
     * @param lasta1currentratio A1相电流带系数
     */
    public void setLasta1currentratio(Float lasta1currentratio) {
        this.lasta1currentratio = lasta1currentratio;
    }

    /**
     * 获取B1相电流带系数
     *
     * @return lastb1currentratio - B1相电流带系数
     */
    public Float getLastb1currentratio() {
        return lastb1currentratio;
    }

    /**
     * 设置B1相电流带系数
     *
     * @param lastb1currentratio B1相电流带系数
     */
    public void setLastb1currentratio(Float lastb1currentratio) {
        this.lastb1currentratio = lastb1currentratio;
    }

    /**
     * 获取C1相电流带系数
     *
     * @return lastc1currentratio - C1相电流带系数
     */
    public Float getLastc1currentratio() {
        return lastc1currentratio;
    }

    /**
     * 设置C1相电流带系数
     *
     * @param lastc1currentratio C1相电流带系数
     */
    public void setLastc1currentratio(Float lastc1currentratio) {
        this.lastc1currentratio = lastc1currentratio;
    }

    /**
     * 获取D1相电流带系数
     *
     * @return lastd1currentratio - D1相电流带系数
     */
    public Float getLastd1currentratio() {
        return lastd1currentratio;
    }

    /**
     * 设置D1相电流带系数
     *
     * @param lastd1currentratio D1相电流带系数
     */
    public void setLastd1currentratio(Float lastd1currentratio) {
        this.lastd1currentratio = lastd1currentratio;
    }

    /**
     * 获取三相不平衡系数
     *
     * @return lastcoefficient - 三相不平衡系数
     */
    public Float getLastcoefficient() {
        return lastcoefficient;
    }

    /**
     * 设置三相不平衡系数
     *
     * @param lastcoefficient 三相不平衡系数
     */
    public void setLastcoefficient(Float lastcoefficient) {
        this.lastcoefficient = lastcoefficient;
    }

    /**
     * 获取三相1不平衡系数
     *
     * @return lastcoefficient1 - 三相1不平衡系数
     */
    public Float getLastcoefficient1() {
        return lastcoefficient1;
    }

    /**
     * 设置三相1不平衡系数
     *
     * @param lastcoefficient1 三相1不平衡系数
     */
    public void setLastcoefficient1(Float lastcoefficient1) {
        this.lastcoefficient1 = lastcoefficient1;
    }

    /**
     * 获取A相报警状态
     *
     * @return lastaalarmstatus - A相报警状态
     */
    public Integer getLastaalarmstatus() {
        return lastaalarmstatus;
    }

    /**
     * 设置A相报警状态
     *
     * @param lastaalarmstatus A相报警状态
     */
    public void setLastaalarmstatus(Integer lastaalarmstatus) {
        this.lastaalarmstatus = lastaalarmstatus;
    }

    /**
     * 获取B相报警状态
     *
     * @return lastbalarmstatus - B相报警状态
     */
    public Integer getLastbalarmstatus() {
        return lastbalarmstatus;
    }

    /**
     * 设置B相报警状态
     *
     * @param lastbalarmstatus B相报警状态
     */
    public void setLastbalarmstatus(Integer lastbalarmstatus) {
        this.lastbalarmstatus = lastbalarmstatus;
    }

    /**
     * 获取C相报警状态
     *
     * @return lastcalarmstatus - C相报警状态
     */
    public Integer getLastcalarmstatus() {
        return lastcalarmstatus;
    }

    /**
     * 设置C相报警状态
     *
     * @param lastcalarmstatus C相报警状态
     */
    public void setLastcalarmstatus(Integer lastcalarmstatus) {
        this.lastcalarmstatus = lastcalarmstatus;
    }

    /**
     * 获取A1相报警状态
     *
     * @return lasta1alarmstatus - A1相报警状态
     */
    public Integer getLasta1alarmstatus() {
        return lasta1alarmstatus;
    }

    /**
     * 设置A1相报警状态
     *
     * @param lasta1alarmstatus A1相报警状态
     */
    public void setLasta1alarmstatus(Integer lasta1alarmstatus) {
        this.lasta1alarmstatus = lasta1alarmstatus;
    }

    /**
     * 获取B1相报警状态
     *
     * @return lastb1alarmstatus - B1相报警状态
     */
    public Integer getLastb1alarmstatus() {
        return lastb1alarmstatus;
    }

    /**
     * 设置B1相报警状态
     *
     * @param lastb1alarmstatus B1相报警状态
     */
    public void setLastb1alarmstatus(Integer lastb1alarmstatus) {
        this.lastb1alarmstatus = lastb1alarmstatus;
    }

    /**
     * 获取C1相报警状态
     *
     * @return lastc1alarmstatus - C1相报警状态
     */
    public Integer getLastc1alarmstatus() {
        return lastc1alarmstatus;
    }

    /**
     * 设置C1相报警状态
     *
     * @param lastc1alarmstatus C1相报警状态
     */
    public void setLastc1alarmstatus(Integer lastc1alarmstatus) {
        this.lastc1alarmstatus = lastc1alarmstatus;
    }

    /**
     * 获取A相报警状态
     *
     * @return lastaralarmstatus - A相报警状态
     */
    public Integer getLastaralarmstatus() {
        return lastaralarmstatus;
    }

    /**
     * 设置A相报警状态
     *
     * @param lastaralarmstatus A相报警状态
     */
    public void setLastaralarmstatus(Integer lastaralarmstatus) {
        this.lastaralarmstatus = lastaralarmstatus;
    }

    /**
     * 获取B相报警状态
     *
     * @return lastbralarmstatus - B相报警状态
     */
    public Integer getLastbralarmstatus() {
        return lastbralarmstatus;
    }

    /**
     * 设置B相报警状态
     *
     * @param lastbralarmstatus B相报警状态
     */
    public void setLastbralarmstatus(Integer lastbralarmstatus) {
        this.lastbralarmstatus = lastbralarmstatus;
    }

    /**
     * 获取C相报警状态
     *
     * @return lastcralarmstatus - C相报警状态
     */
    public Integer getLastcralarmstatus() {
        return lastcralarmstatus;
    }

    /**
     * 设置C相报警状态
     *
     * @param lastcralarmstatus C相报警状态
     */
    public void setLastcralarmstatus(Integer lastcralarmstatus) {
        this.lastcralarmstatus = lastcralarmstatus;
    }

    /**
     * 获取A1相报警状态
     *
     * @return lastar1alarmstatus - A1相报警状态
     */
    public Integer getLastar1alarmstatus() {
        return lastar1alarmstatus;
    }

    /**
     * 设置A1相报警状态
     *
     * @param lastar1alarmstatus A1相报警状态
     */
    public void setLastar1alarmstatus(Integer lastar1alarmstatus) {
        this.lastar1alarmstatus = lastar1alarmstatus;
    }

    /**
     * 获取B1相报警状态
     *
     * @return lastbr1alarmstatus - B1相报警状态
     */
    public Integer getLastbr1alarmstatus() {
        return lastbr1alarmstatus;
    }

    /**
     * 设置B1相报警状态
     *
     * @param lastbr1alarmstatus B1相报警状态
     */
    public void setLastbr1alarmstatus(Integer lastbr1alarmstatus) {
        this.lastbr1alarmstatus = lastbr1alarmstatus;
    }

    /**
     * 获取C1相报警状态
     *
     * @return lastcr1alarmstatus - C1相报警状态
     */
    public Integer getLastcr1alarmstatus() {
        return lastcr1alarmstatus;
    }

    /**
     * 设置C1相报警状态
     *
     * @param lastcr1alarmstatus C1相报警状态
     */
    public void setLastcr1alarmstatus(Integer lastcr1alarmstatus) {
        this.lastcr1alarmstatus = lastcr1alarmstatus;
    }

    /**
     * 获取A相报警状态
     *
     * @return lastabcalarmstatus - A相报警状态
     */
    public Integer getLastabcalarmstatus() {
        return lastabcalarmstatus;
    }

    /**
     * 设置A相报警状态
     *
     * @param lastabcalarmstatus A相报警状态
     */
    public void setLastabcalarmstatus(Integer lastabcalarmstatus) {
        this.lastabcalarmstatus = lastabcalarmstatus;
    }

    /**
     * 获取A1相报警状态
     *
     * @return lastabc1alarmstatus - A1相报警状态
     */
    public Integer getLastabc1alarmstatus() {
        return lastabc1alarmstatus;
    }

    /**
     * 设置A1相报警状态
     *
     * @param lastabc1alarmstatus A1相报警状态
     */
    public void setLastabc1alarmstatus(Integer lastabc1alarmstatus) {
        this.lastabc1alarmstatus = lastabc1alarmstatus;
    }

    /**
     * 获取备注信息。
     *
     * @return memo - 备注信息。
     */
    public String getMemo() {
        return memo;
    }

    /**
     * 设置备注信息。
     *
     * @param memo 备注信息。
     */
    public void setMemo(String memo) {
        this.memo = memo;
    }

    /**
     * 获取vue版的XY坐标
     *
     * @return style - vue版的XY坐标
     */
    public String getStyle() {
        return style;
    }

    /**
     * 设置vue版的XY坐标
     *
     * @param style vue版的XY坐标
     */
    public void setStyle(String style) {
        this.style = style;
    }

    /**
     * 获取值为0为投用,值为1已投用
     *
     * @return inuse - 值为0为投用,值为1已投用
     */
    public Integer getInuse() {
        return inuse;
    }

    /**
     * 设置值为0为投用,值为1已投用
     *
     * @param inuse 值为0为投用,值为1已投用
     */
    public void setInuse(Integer inuse) {
        this.inuse = inuse;
    }

    /**
     * 获取报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     *
     * @return lastalarmlevel - 报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     */
    public Integer getLastalarmlevel() {
        return lastalarmlevel;
    }

    /**
     * 设置报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     *
     * @param lastalarmlevel 报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     */
    public void setLastalarmlevel(Integer lastalarmlevel) {
        this.lastalarmlevel = lastalarmlevel;
    }

    /**
     * 获取上次报警消息。
     *
     * @return lastalarmmessage - 上次报警消息。
     */
    public String getLastalarmmessage() {
        return lastalarmmessage;
    }

    /**
     * 设置上次报警消息。
     *
     * @param lastalarmmessage 上次报警消息。
     */
    public void setLastalarmmessage(String lastalarmmessage) {
        this.lastalarmmessage = lastalarmmessage;
    }

    /**
     * 获取通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     *
     * @return lastcommunicationstatus - 通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     */
    public Integer getLastcommunicationstatus() {
        return lastcommunicationstatus;
    }

    /**
     * 设置通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     *
     * @param lastcommunicationstatus 通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     */
    public void setLastcommunicationstatus(Integer lastcommunicationstatus) {
        this.lastcommunicationstatus = lastcommunicationstatus;
    }

    /**
     * 获取电流报警值
     *
     * @return currentalarmvlaue - 电流报警值
     */
    public Float getCurrentalarmvlaue() {
        return currentalarmvlaue;
    }

    /**
     * 设置电流报警值
     *
     * @param currentalarmvlaue 电流报警值
     */
    public void setCurrentalarmvlaue(Float currentalarmvlaue) {
        this.currentalarmvlaue = currentalarmvlaue;
    }

    /**
     * 获取电流报警解除值
     *
     * @return currentalarmrelievevlaue - 电流报警解除值
     */
    public Float getCurrentalarmrelievevlaue() {
        return currentalarmrelievevlaue;
    }

    /**
     * 设置电流报警解除值
     *
     * @param currentalarmrelievevlaue 电流报警解除值
     */
    public void setCurrentalarmrelievevlaue(Float currentalarmrelievevlaue) {
        this.currentalarmrelievevlaue = currentalarmrelievevlaue;
    }

    /**
     * 获取电流预警值
     *
     * @return currentwarnvlaue - 电流预警值
     */
    public Float getCurrentwarnvlaue() {
        return currentwarnvlaue;
    }

    /**
     * 设置电流预警值
     *
     * @param currentwarnvlaue 电流预警值
     */
    public void setCurrentwarnvlaue(Float currentwarnvlaue) {
        this.currentwarnvlaue = currentwarnvlaue;
    }

    /**
     * 获取电流预警解除值
     *
     * @return currentwarnrelievevlaue - 电流预警解除值
     */
    public Float getCurrentwarnrelievevlaue() {
        return currentwarnrelievevlaue;
    }

    /**
     * 设置电流预警解除值
     *
     * @param currentwarnrelievevlaue 电流预警解除值
     */
    public void setCurrentwarnrelievevlaue(Float currentwarnrelievevlaue) {
        this.currentwarnrelievevlaue = currentwarnrelievevlaue;
    }

    /**
     * 获取电流比报警值
     *
     * @return currentpercentagealarmvlaue - 电流比报警值
     */
    public Float getCurrentpercentagealarmvlaue() {
        return currentpercentagealarmvlaue;
    }

    /**
     * 设置电流比报警值
     *
     * @param currentpercentagealarmvlaue 电流比报警值
     */
    public void setCurrentpercentagealarmvlaue(Float currentpercentagealarmvlaue) {
        this.currentpercentagealarmvlaue = currentpercentagealarmvlaue;
    }

    /**
     * 获取电流比报警解除值
     *
     * @return currentpercentagealarmrelievevlaue - 电流比报警解除值
     */
    public Float getCurrentpercentagealarmrelievevlaue() {
        return currentpercentagealarmrelievevlaue;
    }

    /**
     * 设置电流比报警解除值
     *
     * @param currentpercentagealarmrelievevlaue 电流比报警解除值
     */
    public void setCurrentpercentagealarmrelievevlaue(Float currentpercentagealarmrelievevlaue) {
        this.currentpercentagealarmrelievevlaue = currentpercentagealarmrelievevlaue;
    }

    /**
     * 获取电流比预警值
     *
     * @return currentpercentagewarnvlaue - 电流比预警值
     */
    public Float getCurrentpercentagewarnvlaue() {
        return currentpercentagewarnvlaue;
    }

    /**
     * 设置电流比预警值
     *
     * @param currentpercentagewarnvlaue 电流比预警值
     */
    public void setCurrentpercentagewarnvlaue(Float currentpercentagewarnvlaue) {
        this.currentpercentagewarnvlaue = currentpercentagewarnvlaue;
    }

    /**
     * 获取电流比预警解除值
     *
     * @return currentpercentagewarnrelievevlaue - 电流比预警解除值
     */
    public Float getCurrentpercentagewarnrelievevlaue() {
        return currentpercentagewarnrelievevlaue;
    }

    /**
     * 设置电流比预警解除值
     *
     * @param currentpercentagewarnrelievevlaue 电流比预警解除值
     */
    public void setCurrentpercentagewarnrelievevlaue(Float currentpercentagewarnrelievevlaue) {
        this.currentpercentagewarnrelievevlaue = currentpercentagewarnrelievevlaue;
    }

    /**
     * 获取不平衡系数报警值
     *
     * @return coefficientalarmvlaue - 不平衡系数报警值
     */
    public Float getCoefficientalarmvlaue() {
        return coefficientalarmvlaue;
    }

    /**
     * 设置不平衡系数报警值
     *
     * @param coefficientalarmvlaue 不平衡系数报警值
     */
    public void setCoefficientalarmvlaue(Float coefficientalarmvlaue) {
        this.coefficientalarmvlaue = coefficientalarmvlaue;
    }

    /**
     * 获取不平衡系数报警解除值
     *
     * @return coefficientalarmrelievevlaue - 不平衡系数报警解除值
     */
    public Float getCoefficientalarmrelievevlaue() {
        return coefficientalarmrelievevlaue;
    }

    /**
     * 设置不平衡系数报警解除值
     *
     * @param coefficientalarmrelievevlaue 不平衡系数报警解除值
     */
    public void setCoefficientalarmrelievevlaue(Float coefficientalarmrelievevlaue) {
        this.coefficientalarmrelievevlaue = coefficientalarmrelievevlaue;
    }

    /**
     * 获取不平衡系数预警值
     *
     * @return coefficientwarnvlaue - 不平衡系数预警值
     */
    public Float getCoefficientwarnvlaue() {
        return coefficientwarnvlaue;
    }

    /**
     * 设置不平衡系数预警值
     *
     * @param coefficientwarnvlaue 不平衡系数预警值
     */
    public void setCoefficientwarnvlaue(Float coefficientwarnvlaue) {
        this.coefficientwarnvlaue = coefficientwarnvlaue;
    }

    /**
     * 获取不平衡系数预警解除值
     *
     * @return coefficientwarnrelievevlaue - 不平衡系数预警解除值
     */
    public Float getCoefficientwarnrelievevlaue() {
        return coefficientwarnrelievevlaue;
    }

    /**
     * 设置不平衡系数预警解除值
     *
     * @param coefficientwarnrelievevlaue 不平衡系数预警解除值
     */
    public void setCoefficientwarnrelievevlaue(Float coefficientwarnrelievevlaue) {
        this.coefficientwarnrelievevlaue = coefficientwarnrelievevlaue;
    }

    /**
     * 获取A相电流系数>5
     *
     * @return acurrentcoefficientgreatevalue - A相电流系数>5
     */
    public Float getAcurrentcoefficientgreatevalue() {
        return acurrentcoefficientgreatevalue;
    }

    /**
     * 设置A相电流系数>5
     *
     * @param acurrentcoefficientgreatevalue A相电流系数>5
     */
    public void setAcurrentcoefficientgreatevalue(Float acurrentcoefficientgreatevalue) {
        this.acurrentcoefficientgreatevalue = acurrentcoefficientgreatevalue;
    }

    /**
     * 获取偏移量
     *
     * @return acurrentbgreatevalue - 偏移量
     */
    public Float getAcurrentbgreatevalue() {
        return acurrentbgreatevalue;
    }

    /**
     * 设置偏移量
     *
     * @param acurrentbgreatevalue 偏移量
     */
    public void setAcurrentbgreatevalue(Float acurrentbgreatevalue) {
        this.acurrentbgreatevalue = acurrentbgreatevalue;
    }

    /**
     * 获取B相电流系数>5
     *
     * @return bcurrentcoefficientgreatevalue - B相电流系数>5
     */
    public Float getBcurrentcoefficientgreatevalue() {
        return bcurrentcoefficientgreatevalue;
    }

    /**
     * 设置B相电流系数>5
     *
     * @param bcurrentcoefficientgreatevalue B相电流系数>5
     */
    public void setBcurrentcoefficientgreatevalue(Float bcurrentcoefficientgreatevalue) {
        this.bcurrentcoefficientgreatevalue = bcurrentcoefficientgreatevalue;
    }

    /**
     * @return bcurrentbgreatevalue
     */
    public Float getBcurrentbgreatevalue() {
        return bcurrentbgreatevalue;
    }

    /**
     * @param bcurrentbgreatevalue
     */
    public void setBcurrentbgreatevalue(Float bcurrentbgreatevalue) {
        this.bcurrentbgreatevalue = bcurrentbgreatevalue;
    }

    /**
     * 获取C相电流系数>5
     *
     * @return ccurrentcoefficientgreatevalue - C相电流系数>5
     */
    public Float getCcurrentcoefficientgreatevalue() {
        return ccurrentcoefficientgreatevalue;
    }

    /**
     * 设置C相电流系数>5
     *
     * @param ccurrentcoefficientgreatevalue C相电流系数>5
     */
    public void setCcurrentcoefficientgreatevalue(Float ccurrentcoefficientgreatevalue) {
        this.ccurrentcoefficientgreatevalue = ccurrentcoefficientgreatevalue;
    }

    /**
     * @return ccurrentbgreatevalue
     */
    public Float getCcurrentbgreatevalue() {
        return ccurrentbgreatevalue;
    }

    /**
     * @param ccurrentbgreatevalue
     */
    public void setCcurrentbgreatevalue(Float ccurrentbgreatevalue) {
        this.ccurrentbgreatevalue = ccurrentbgreatevalue;
    }

    /**
     * 获取A1相电流系数>5
     *
     * @return a1currentcoefficientgreatevalue - A1相电流系数>5
     */
    public Float getA1currentcoefficientgreatevalue() {
        return a1currentcoefficientgreatevalue;
    }

    /**
     * 设置A1相电流系数>5
     *
     * @param a1currentcoefficientgreatevalue A1相电流系数>5
     */
    public void setA1currentcoefficientgreatevalue(Float a1currentcoefficientgreatevalue) {
        this.a1currentcoefficientgreatevalue = a1currentcoefficientgreatevalue;
    }

    /**
     * 获取B1相电流系数>5
     *
     * @return b1currentcoefficientgreatevalue - B1相电流系数>5
     */
    public Float getB1currentcoefficientgreatevalue() {
        return b1currentcoefficientgreatevalue;
    }

    /**
     * 设置B1相电流系数>5
     *
     * @param b1currentcoefficientgreatevalue B1相电流系数>5
     */
    public void setB1currentcoefficientgreatevalue(Float b1currentcoefficientgreatevalue) {
        this.b1currentcoefficientgreatevalue = b1currentcoefficientgreatevalue;
    }

    /**
     * 获取C1相电流系数>5
     *
     * @return c1currentcoefficientgreatevalue - C1相电流系数>5
     */
    public Float getC1currentcoefficientgreatevalue() {
        return c1currentcoefficientgreatevalue;
    }

    /**
     * 设置C1相电流系数>5
     *
     * @param c1currentcoefficientgreatevalue C1相电流系数>5
     */
    public void setC1currentcoefficientgreatevalue(Float c1currentcoefficientgreatevalue) {
        this.c1currentcoefficientgreatevalue = c1currentcoefficientgreatevalue;
    }

    /**
     * 获取母线电流系数>5
     *
     * @return dcurrentcoefficientgreatevalue - 母线电流系数>5
     */
    public Float getDcurrentcoefficientgreatevalue() {
        return dcurrentcoefficientgreatevalue;
    }

    /**
     * 设置母线电流系数>5
     *
     * @param dcurrentcoefficientgreatevalue 母线电流系数>5
     */
    public void setDcurrentcoefficientgreatevalue(Float dcurrentcoefficientgreatevalue) {
        this.dcurrentcoefficientgreatevalue = dcurrentcoefficientgreatevalue;
    }

    /**
     * @return dcurrentbgreatevalue
     */
    public Float getDcurrentbgreatevalue() {
        return dcurrentbgreatevalue;
    }

    /**
     * @param dcurrentbgreatevalue
     */
    public void setDcurrentbgreatevalue(Float dcurrentbgreatevalue) {
        this.dcurrentbgreatevalue = dcurrentbgreatevalue;
    }

    /**
     * 获取A相电流系数<5
     *
     * @return acurrentcoefficientlessvalue - A相电流系数<5
     */
    public Float getAcurrentcoefficientlessvalue() {
        return acurrentcoefficientlessvalue;
    }

    /**
     * 设置A相电流系数<5
     *
     * @param acurrentcoefficientlessvalue A相电流系数<5
     */
    public void setAcurrentcoefficientlessvalue(Float acurrentcoefficientlessvalue) {
        this.acurrentcoefficientlessvalue = acurrentcoefficientlessvalue;
    }

    /**
     * 获取偏移量
     *
     * @return acurrentblessvalue - 偏移量
     */
    public Float getAcurrentblessvalue() {
        return acurrentblessvalue;
    }

    /**
     * 设置偏移量
     *
     * @param acurrentblessvalue 偏移量
     */
    public void setAcurrentblessvalue(Float acurrentblessvalue) {
        this.acurrentblessvalue = acurrentblessvalue;
    }

    /**
     * 获取B相电流系数<5
     *
     * @return bcurrentcoefficientlessvalue - B相电流系数<5
     */
    public Float getBcurrentcoefficientlessvalue() {
        return bcurrentcoefficientlessvalue;
    }

    /**
     * 设置B相电流系数<5
     *
     * @param bcurrentcoefficientlessvalue B相电流系数<5
     */
    public void setBcurrentcoefficientlessvalue(Float bcurrentcoefficientlessvalue) {
        this.bcurrentcoefficientlessvalue = bcurrentcoefficientlessvalue;
    }

    /**
     * @return bcurrentblessvalue
     */
    public Float getBcurrentblessvalue() {
        return bcurrentblessvalue;
    }

    /**
     * @param bcurrentblessvalue
     */
    public void setBcurrentblessvalue(Float bcurrentblessvalue) {
        this.bcurrentblessvalue = bcurrentblessvalue;
    }

    /**
     * 获取C相电流系数<5
     *
     * @return ccurrentcoefficientlessvalue - C相电流系数<5
     */
    public Float getCcurrentcoefficientlessvalue() {
        return ccurrentcoefficientlessvalue;
    }

    /**
     * 设置C相电流系数<5
     *
     * @param ccurrentcoefficientlessvalue C相电流系数<5
     */
    public void setCcurrentcoefficientlessvalue(Float ccurrentcoefficientlessvalue) {
        this.ccurrentcoefficientlessvalue = ccurrentcoefficientlessvalue;
    }

    /**
     * @return cccurrentblessvalue
     */
    public Float getCccurrentblessvalue() {
        return cccurrentblessvalue;
    }

    /**
     * @param cccurrentblessvalue
     */
    public void setCccurrentblessvalue(Float cccurrentblessvalue) {
        this.cccurrentblessvalue = cccurrentblessvalue;
    }

    /**
     * 获取A1相电流系数<5
     *
     * @return a1currentcoefficientlessvalue - A1相电流系数<5
     */
    public Float getA1currentcoefficientlessvalue() {
        return a1currentcoefficientlessvalue;
    }

    /**
     * 设置A1相电流系数<5
     *
     * @param a1currentcoefficientlessvalue A1相电流系数<5
     */
    public void setA1currentcoefficientlessvalue(Float a1currentcoefficientlessvalue) {
        this.a1currentcoefficientlessvalue = a1currentcoefficientlessvalue;
    }

    /**
     * 获取B1相电流系数<5
     *
     * @return b1currentcoefficientlessvalue - B1相电流系数<5
     */
    public Float getB1currentcoefficientlessvalue() {
        return b1currentcoefficientlessvalue;
    }

    /**
     * 设置B1相电流系数<5
     *
     * @param b1currentcoefficientlessvalue B1相电流系数<5
     */
    public void setB1currentcoefficientlessvalue(Float b1currentcoefficientlessvalue) {
        this.b1currentcoefficientlessvalue = b1currentcoefficientlessvalue;
    }

    /**
     * 获取C1相电流系数<5
     *
     * @return c1currentcoefficientlessvalue - C1相电流系数<5
     */
    public Float getC1currentcoefficientlessvalue() {
        return c1currentcoefficientlessvalue;
    }

    /**
     * 设置C1相电流系数<5
     *
     * @param c1currentcoefficientlessvalue C1相电流系数<5
     */
    public void setC1currentcoefficientlessvalue(Float c1currentcoefficientlessvalue) {
        this.c1currentcoefficientlessvalue = c1currentcoefficientlessvalue;
    }

    /**
     * @return ccurrentblessvalue
     */
    public String getCcurrentblessvalue() {
        return ccurrentblessvalue;
    }

    /**
     * @param ccurrentblessvalue
     */
    public void setCcurrentblessvalue(String ccurrentblessvalue) {
        this.ccurrentblessvalue = ccurrentblessvalue;
    }

    /**
     * @return dcurrentcoefficientlessvalue
     */
    public Float getDcurrentcoefficientlessvalue() {
        return dcurrentcoefficientlessvalue;
    }

    /**
     * @param dcurrentcoefficientlessvalue
     */
    public void setDcurrentcoefficientlessvalue(Float dcurrentcoefficientlessvalue) {
        this.dcurrentcoefficientlessvalue = dcurrentcoefficientlessvalue;
    }

    /**
     * @return dcurrentblessvalue
     */
    public Float getDcurrentblessvalue() {
        return dcurrentblessvalue;
    }

    /**
     * @param dcurrentblessvalue
     */
    public void setDcurrentblessvalue(Float dcurrentblessvalue) {
        this.dcurrentblessvalue = dcurrentblessvalue;
    }
}